package es.geoorge.hundirlaflota;

/**
 * La Maquina es la encargada de calcular y modificar el array de coordenadas validas y razonables para usarlas en los turnos de la maquina.
 * @author Georthik
 * @version x.x
 */
public class Maquina implements Runnable{		
	int max=50;
	String[] arrCoordenadas;
	Mensajero mens;
	boolean finJuego=false;

	/**
	 * Crea la clase, llama al metodo encargado de generar el array de coordenadas y se envia a si misma a la clase intermediaria, Mensajero.
	 * @param mens es la clase intermediaria
	 */
	public Maquina(Mensajero mens){
		arrCoordenadas=generarArrayCoordenadas();
		this.mens=mens;
		mens.enviarMaquina(this);
	}
	
	/**
	 * Genera un array de coordenadas validas para la matriz del juego basandose en la idea de que los barcos no pueden colocarse en posiciones diagonales y que la longitud minima
	 * es de dos casillas.
	 * @return
	 */
	public String[] generarArrayCoordenadas(){
		String []array=new String[max];
		int n=0;
		for(int i=0;i<10;i++){
			for(int j=0;j<10;j++){
				if(j%2==0){
					if(i%2==0){
						array[n]=i+","+j;
						n++;
					}
				}else{
					if(i%2!=0){
						array[n]=i+","+j;
						n++;
					}
				}
			}
		}
		return array;
	}
		
	/**
	 * Recive una coordenada generada por otra clase y comprueba si esta dentro del array que se genera en el constructor
	 * @param x la coordenada x en la matriz numerica del juego.
	 * @param y la coordenada y en la matriz numerica del juego.
	 * @return en caso de que la coordenada este en el array devuelve la posicion de esta, en caso contrario devuelve -1.
	 */
	public int buscarCoor(int x,int y){
		for(int i=0;i<max;i++){
			if(arrCoordenadas[i].equals(x+","+y)){
				return i;
			}
		}
		return -1;
	}
	
	/**
	 * Este metodo se encarga de acortar el array de coordenadas posibles, generalmente recive la posicion devuelta del metodo buscarCoor()
	 * @param param el array de coordenadas a redimensionar.
	 * @param x  la posicion de la coordenada que queremos eliminar del array
	 * @return devuelve el nuevo array sin la coordenada que hubiera en la posicion x.
	 */
	public String[] nuevoArray(String[] param, int x){
		String[] arrAux=new String[--max];
		for(int i=0;i<x;i++){
			arrAux[i]=param[i];
		}
		for(int i=x;i<max;i++){
			arrAux[i]=param[i+1];
			
		}
		param=new String[max];
		for(int i=0;i<max;i++){
			param[i]=arrAux[i];
		}
		return param;
	}
	
	/**
	 * Este metodo se encarga de eliminar del array de coordenadas validas las casillas adyacentes a la casilla cuya coordenadas recibe.
	 * Tiene su utilidad para, una vez tocado un barco, eliminar las casillas donde no es posible que haya barcos y asi evitar perdidas de turnos.
	 * @param x la coordenada x en la matriz numerica del juego.
	 * @param y la coordenada x en la matriz numerica del juego.
	 */
	public void ponAgua(int x, int y){
		if(buscarCoor(x-1,y-1)!=-1){
			arrCoordenadas=nuevoArray(arrCoordenadas,buscarCoor(x-1,y-1));
		}
		if(buscarCoor(x-1,y+1)!=-1){
			arrCoordenadas=nuevoArray(arrCoordenadas,buscarCoor(x-1,y+1));
		}
		if(buscarCoor(x+1,y-1)!=-1){
			arrCoordenadas=nuevoArray(arrCoordenadas,buscarCoor(x+1,y-1));
		}
		if(buscarCoor(x+1,y+1)!=-1){
			arrCoordenadas=nuevoArray(arrCoordenadas,buscarCoor(x+1,y+1));
		}		
	}

	/**
	 * Como implementa Runnable la Maquina para poder hacer pausas en su ejecucion cuando detecta coordenadas de agua y asi respetar los turnos del jugador se debe poner el metodo run.
	 * Al principio se queda "dormido" hasta que se detecta que la partida ha empezado, entonces comienza a generar coordenadas aleatorias respetando turnos.
	 */
	@Override
	public void run(){
		boolean error=false;
		do{
			error=false;
			try{
				if(mens.tableroJugador.jugando);
			}catch(Exception e){
				error=true;
				try {
					Thread.sleep(500);
				} catch (InterruptedException e1) {
					e.printStackTrace();
				}
			}
		}while(error);
		do{
			mens.generarCoor();
		}while(mens.barcosJugadorHundidos<5);
		mens.ganaLaMaquina();
	}
}

